package com.evan.review.basic.thread;

import android.os.Bundle;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;
import com.evan.review.R;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.Condition;

/**
 * Java线程与线程池详解Activity
 * 
 * 本Activity详细讲解了Java并发编程的核心概念和工具：
 * 1. 线程基础知识与生命周期
 * 2. 线程池原理与使用
 * 3. 同步器机制（AQS、锁、信号量等）
 * 4. CAS与原子操作
 * 5. 并发容器
 * 6. 常见面试题与实践案例
 */
public class ThreadPoolActivity extends AppCompatActivity {
    
    private TextView tvOutput;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_data_structure);
        
        setTitle("Java线程与并发编程");
        
        tvOutput = findViewById(R.id.tv_output);
        
        // 展示线程基础知识
        demonstrateThreadBasics();
        
        // 展示线程池原理与使用
        demonstrateThreadPools();
        
        // 展示同步器（AQS及其实现）
        demonstrateSynchronizers();
        
        // 展示CAS与原子操作
        demonstrateCasAndAtomic();
        
        // 展示常见并发面试题
        demonstrateInterviewQuestions();
    }
    
    /**
     * 展示线程基础知识
     */
    private void demonstrateThreadBasics() {
        StringBuilder output = new StringBuilder();
        output.append("=== Java线程基础 ===\n\n");
        
        // 1. 线程的创建方式
        output.append("1. 线程创建的三种方式：\n");
        output.append("① 继承Thread类\n");
        output.append("② 实现Runnable接口\n");
        output.append("③ 实现Callable接口（可返回结果）\n\n");
        
        output.append("// 方式一：继承Thread类\n");
        output.append("class MyThread extends Thread {\n");
        output.append("    @Override\n");
        output.append("    public void run() {\n");
        output.append("        // 线程执行逻辑\n");
        output.append("    }\n");
        output.append("}\n");
        output.append("MyThread thread = new MyThread();\n");
        output.append("thread.start();\n\n");
        
        output.append("// 方式二：实现Runnable接口\n");
        output.append("Runnable runnable = new Runnable() {\n");
        output.append("    @Override\n");
        output.append("    public void run() {\n");
        output.append("        // 线程执行逻辑\n");
        output.append("    }\n");
        output.append("};\n");
        output.append("new Thread(runnable).start();\n\n");
        
        output.append("// 方式三：实现Callable接口\n");
        output.append("Callable<String> callable = new Callable<String>() {\n");
        output.append("    @Override\n");
        output.append("    public String call() throws Exception {\n");
        output.append("        // 线程执行逻辑\n");
        output.append("        return \"返回结果\";\n");
        output.append("    }\n");
        output.append("};\n");
        output.append("FutureTask<String> futureTask = new FutureTask<>(callable);\n");
        output.append("new Thread(futureTask).start();\n");
        output.append("// 获取返回值（会阻塞直到结果可用）\n");
        output.append("String result = futureTask.get();\n\n");
        
        // 2. 线程生命周期
        output.append("2. 线程的生命周期：\n");
        output.append("• 新建（New）：线程对象被创建\n");
        output.append("• 就绪（Runnable）：调用start()方法后等待CPU调度\n");
        output.append("• 运行（Running）：获得CPU时间片正在执行\n");
        output.append("• 阻塞（Blocked）：等待锁或I/O操作\n");
        output.append("• 等待（Waiting）：等待其他线程通知\n");
        output.append("• 超时等待（Timed Waiting）：限时等待\n");
        output.append("• 终止（Terminated）：线程执行结束\n\n");
        
        // 3. 线程方法
        output.append("3. 重要线程方法：\n");
        output.append("• start()：启动线程\n");
        output.append("• run()：线程执行体\n");
        output.append("• sleep(long)：线程休眠，不释放锁\n");
        output.append("• yield()：让出CPU，但仍处于就绪状态\n");
        output.append("• join()：等待线程终止\n");
        output.append("• interrupt()：中断线程\n");
        output.append("• isAlive()：判断线程是否存活\n\n");
        
        // 4. 线程优先级
        output.append("4. 线程优先级：\n");
        output.append("• Java线程优先级范围：1(最低)～10(最高)\n");
        output.append("• 默认优先级：5 (NORM_PRIORITY)\n");
        output.append("• 设置方法：thread.setPriority(int)\n");
        output.append("• 优先级仅作为调度参考，不保证顺序\n");
        
        updateOutput(output.toString());
    }
    
    /**
     * 展示线程池原理与使用
     */
    private void demonstrateThreadPools() {
        StringBuilder output = new StringBuilder();
        output.append("\n=== 线程池原理与使用 ===\n\n");
        
        // 1. 线程池核心参数
        output.append("1. 线程池核心参数：\n");
        output.append("• corePoolSize：核心线程数\n");
        output.append("• maximumPoolSize：最大线程数\n");
        output.append("• keepAliveTime：空闲线程存活时间\n");
        output.append("• workQueue：工作队列，存放待执行任务\n");
        output.append("• threadFactory：线程工厂，创建新线程\n");
        output.append("• handler：拒绝策略，队列满且线程数达到maximumPoolSize时的处理策略\n\n");
        
        // 2. 线程池工作原理
        output.append("2. 线程池工作原理：\n");
        output.append("• 提交任务 → 核心线程池是否已满？\n");
        output.append("  → 否：创建新的核心线程执行任务\n");
        output.append("  → 是：工作队列是否已满？\n");
        output.append("    → 否：将任务放入工作队列\n");
        output.append("    → 是：线程池是否已满？\n");
        output.append("      → 否：创建新的非核心线程执行任务\n");
        output.append("      → 是：执行拒绝策略\n\n");
        
        // 3. JDK提供的线程池
        output.append("3. JDK提供的线程池：\n");
        output.append("① FixedThreadPool：固定线程数线程池\n");
        output.append("ExecutorService fixedPool = Executors.newFixedThreadPool(5);\n");
        output.append("特点：核心线程数等于最大线程数，无空闲线程超时机制\n\n");
        
        output.append("② CachedThreadPool：缓存线程池\n");
        output.append("ExecutorService cachedPool = Executors.newCachedThreadPool();\n");
        output.append("特点：核心线程数为0，最大线程数为Integer.MAX_VALUE，空闲线程60秒后回收\n\n");
        
        output.append("③ ScheduledThreadPool：定时线程池\n");
        output.append("ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(5);\n");
        output.append("特点：支持定时及周期性任务执行\n\n");
        
        output.append("④ SingleThreadExecutor：单线程线程池\n");
        output.append("ExecutorService singlePool = Executors.newSingleThreadExecutor();\n");
        output.append("特点：只有一个工作线程，保证任务顺序执行\n\n");
        
        // 4. 四种拒绝策略
        output.append("4. 四种拒绝策略：\n");
        output.append("• AbortPolicy：默认策略，抛出RejectedExecutionException异常\n");
        output.append("• DiscardPolicy：丢弃任务，不抛异常\n");
        output.append("• DiscardOldestPolicy：丢弃队列头部（最旧）任务，尝试重新提交当前任务\n");
        output.append("• CallerRunsPolicy：由调用线程执行任务\n\n");
        
        // 5. 自定义线程池
        output.append("5. 自定义线程池示例：\n");
        output.append("ThreadPoolExecutor executor = new ThreadPoolExecutor(\n");
        output.append("    2,                      // 核心线程数\n");
        output.append("    5,                      // 最大线程数\n");
        output.append("    60L,                    // 空闲线程存活时间\n");
        output.append("    TimeUnit.SECONDS,       // 时间单位\n");
        output.append("    new LinkedBlockingQueue<>(10), // 工作队列\n");
        output.append("    Executors.defaultThreadFactory(), // 线程工厂\n");
        output.append("    new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略\n");
        output.append(");\n\n");
        
        // 6. 线程池正确使用与注意事项
        output.append("6. 线程池使用注意事项：\n");
        output.append("• 避免使用Executors工厂方法（可能OOM），推荐直接使用ThreadPoolExecutor\n");
        output.append("• 根据业务特性合理设置参数\n");
        output.append("• 关闭线程池：shutdown()（等待任务完成）或shutdownNow()（立即停止）\n");
        output.append("• CPU密集型任务：线程数 = CPU核心数 + 1\n");
        output.append("• IO密集型任务：线程数 = CPU核心数 * (1 + IO耗时/CPU耗时)\n");
        
        updateOutput(output.toString());
    }
    
    /**
     * 展示同步器（AQS及其实现）
     */
    private void demonstrateSynchronizers() {
        StringBuilder output = new StringBuilder();
        output.append("\n=== 同步器机制 ===\n\n");
        
        // 1. AQS框架介绍
        output.append("1. AQS（AbstractQueuedSynchronizer）：\n");
        output.append("• 是Java并发包中实现同步器的基础框架\n");
        output.append("• 底层使用volatile修饰的state变量表示同步状态\n");
        output.append("• 使用FIFO队列管理等待线程\n");
        output.append("• 子类通过继承并实现相关方法来管理同步状态\n\n");
        
        output.append("AQS核心属性和方法：\n");
        output.append("• volatile int state：同步状态\n");
        output.append("• getState()：获取状态\n");
        output.append("• setState()：设置状态\n");
        output.append("• compareAndSetState()：CAS更新状态\n");
        output.append("• acquire()：独占式获取同步状态\n");
        output.append("• release()：独占式释放同步状态\n");
        output.append("• acquireShared()：共享式获取同步状态\n");
        output.append("• releaseShared()：共享式释放同步状态\n\n");
        
        // 2. 重要的AQS实现类
        output.append("2. 基于AQS的同步器：\n");
        
        output.append("① ReentrantLock（可重入锁）：\n");
        output.append("• 可替代synchronized的显式锁\n");
        output.append("• 支持公平锁和非公平锁\n");
        output.append("• 支持可中断获取锁\n");
        output.append("• 支持超时获取锁\n");
        output.append("• 支持尝试获取锁\n");
        output.append("• 可以判断是否持有锁\n\n");
        
        output.append("示例代码：\n");
        output.append("Lock lock = new ReentrantLock(); // 默认非公平锁\n");
        output.append("lock.lock(); // 获取锁\n");
        output.append("try {\n");
        output.append("    // 临界区代码\n");
        output.append("} finally {\n");
        output.append("    lock.unlock(); // 释放锁\n");
        output.append("}\n\n");
        
        output.append("② Semaphore（信号量）：\n");
        output.append("• 控制同时访问特定资源的线程数量\n");
        output.append("• 常用于限流\n\n");
        
        output.append("示例代码：\n");
        output.append("Semaphore semaphore = new Semaphore(3); // 3个许可证\n");
        output.append("semaphore.acquire(); // 获取许可\n");
        output.append("try {\n");
        output.append("    // 访问资源\n");
        output.append("} finally {\n");
        output.append("    semaphore.release(); // 释放许可\n");
        output.append("}\n\n");
        
        output.append("③ CountDownLatch（倒计时器）：\n");
        output.append("• 让一个或多个线程等待其他线程完成操作\n");
        output.append("• 适用于一次性等待场景\n\n");
        
        output.append("示例代码：\n");
        output.append("CountDownLatch latch = new CountDownLatch(3); // 需要等待3个任务\n");
        output.append("// 任务线程中\n");
        output.append("latch.countDown(); // 任务完成，计数器-1\n");
        output.append("// 主线程中\n");
        output.append("latch.await(); // 等待计数器为0\n\n");
        
        output.append("④ CyclicBarrier（循环栅栏）：\n");
        output.append("• 让一组线程相互等待，直到所有线程都到达某个公共屏障点\n");
        output.append("• 支持循环使用\n\n");
        
        output.append("示例代码：\n");
        output.append("CyclicBarrier barrier = new CyclicBarrier(3, () -> {\n");
        output.append("    // 所有线程到达屏障后执行的操作\n");
        output.append("});\n");
        output.append("// 线程中调用\n");
        output.append("barrier.await(); // 等待所有线程到达屏障\n\n");
        
        output.append("⑤ Phaser：\n");
        output.append("• 更灵活的控制并发阶段\n");
        output.append("• 可动态调整参与的线程数\n\n");
        
        // 3. Condition
        output.append("3. Condition（条件变量）：\n");
        output.append("• 与Lock配合使用，替代Object的wait/notify\n");
        output.append("• 支持多个等待队列\n");
        output.append("• 提供更精确的线程唤醒\n\n");
        
        output.append("示例代码：\n");
        output.append("Lock lock = new ReentrantLock();\n");
        output.append("Condition condition = lock.newCondition();\n");
        output.append("lock.lock();\n");
        output.append("try {\n");
        output.append("    condition.await(); // 等待条件，释放锁\n");
        output.append("    // 条件满足后继续执行\n");
        output.append("} finally {\n");
        output.append("    lock.unlock();\n");
        output.append("}\n");
        output.append("// 在另一个线程中\n");
        output.append("lock.lock();\n");
        output.append("try {\n");
        output.append("    condition.signal(); // 唤醒等待线程\n");
        output.append("} finally {\n");
        output.append("    lock.unlock();\n");
        output.append("}\n");
        
        updateOutput(output.toString());
    }
    
    /**
     * 展示CAS与原子操作
     */
    private void demonstrateCasAndAtomic() {
        StringBuilder output = new StringBuilder();
        output.append("\n=== CAS与原子操作 ===\n\n");
        
        // 1. CAS原理
        output.append("1. CAS（Compare And Swap）原理：\n");
        output.append("• 是一种无锁算法，CPU原子指令\n");
        output.append("• 原理：比较并交换，只有当预期值与当前值相等时，才更新新值\n");
        output.append("• 过程：\n");
        output.append("  1) 读取当前值A\n");
        output.append("  2) 基于A计算新值B\n");
        output.append("  3) 比较当前值是否仍为A\n");
        output.append("  4) 如果是，则更新为B；否则重试或失败\n\n");
        
        output.append("CAS操作的Java实现依赖于Unsafe类的native方法：\n");
        output.append("public final native boolean compareAndSwapInt(\n");
        output.append("    Object o, long offset, int expected, int x);\n\n");
        
        // 2. CAS的问题
        output.append("2. CAS的三大问题：\n");
        output.append("① ABA问题：\n");
        output.append("• 值从A变为B再变回A，CAS检测不出变化\n");
        output.append("• 解决：使用版本号/时间戳（AtomicStampedReference）\n\n");
        
        output.append("② 循环时间开销：\n");
        output.append("• 自旋CAS长时间不成功会消耗CPU\n");
        output.append("• 解决：设置自旋次数上限，或使用自适应自旋\n\n");
        
        output.append("③ 只能保证单个变量的原子操作：\n");
        output.append("• 无法保证多个变量的原子性\n");
        output.append("• 解决：使用AtomicReference封装对象，或使用锁\n\n");
        
        // 3. 原子类
        output.append("3. Java原子类：\n");
        output.append("① 基本类型：\n");
        output.append("• AtomicInteger, AtomicLong, AtomicBoolean\n\n");
        
        output.append("② 数组类型：\n");
        output.append("• AtomicIntegerArray, AtomicLongArray, AtomicReferenceArray\n\n");
        
        output.append("③ 引用类型：\n");
        output.append("• AtomicReference: 对象引用的原子更新\n");
        output.append("• AtomicStampedReference: 带有版本号的对象引用原子更新（解决ABA问题）\n");
        output.append("• AtomicMarkableReference: 带有标记的对象引用原子更新\n\n");
        
        output.append("④ 字段更新器：\n");
        output.append("• AtomicIntegerFieldUpdater\n");
        output.append("• AtomicLongFieldUpdater\n");
        output.append("• AtomicReferenceFieldUpdater\n\n");
        
        output.append("⑤ 累加器（Java 8新增）：\n");
        output.append("• LongAdder, DoubleAdder: 高并发下比原子类性能更好\n");
        output.append("• LongAccumulator, DoubleAccumulator: 支持自定义累加操作\n\n");
        
        // 4. 示例代码
        output.append("4. 原子类使用示例：\n");
        output.append("// AtomicInteger示例\n");
        output.append("AtomicInteger count = new AtomicInteger(0);\n");
        output.append("count.incrementAndGet(); // 原子+1并获取结果\n");
        output.append("count.addAndGet(5);     // 原子+5并获取结果\n");
        output.append("count.getAndIncrement(); // 获取当前值并原子+1\n\n");
        
        output.append("// 原子更新引用\n");
        output.append("AtomicReference<User> userRef = new AtomicReference<>(new User(\"张三\", 20));\n");
        output.append("userRef.compareAndSet(oldUser, newUser); // CAS更新对象\n\n");
        
        output.append("// LongAdder(高并发计数器)\n");
        output.append("LongAdder adder = new LongAdder();\n");
        output.append("adder.increment(); // +1\n");
        output.append("adder.add(5);      // +5\n");
        output.append("long sum = adder.sum(); // 获取结果\n");
        
        updateOutput(output.toString());
    }
    
    /**
     * 展示并发编程面试题
     */
    private void demonstrateInterviewQuestions() {
        StringBuilder output = new StringBuilder();
        output.append("\n=== 并发编程面试题 ===\n\n");
        
        // 1. synchronized和ReentrantLock的区别
        output.append("1. synchronized与ReentrantLock的区别？\n");
        output.append("答：主要区别：\n");
        output.append("• 实现方式：synchronized是JVM层面的关键字；ReentrantLock是JDK层面的类\n");
        output.append("• 灵活性：ReentrantLock更灵活（可中断、超时、尝试获取、公平锁选择）\n");
        output.append("• 等待通知机制：synchronized用Object的wait/notify；ReentrantLock用Condition\n");
        output.append("• 可重入性：两者都是可重入锁，但ReentrantLock可以查询锁状态\n");
        output.append("• 性能：JDK1.6后synchronized进行了优化，两者性能接近\n\n");
        
        // 2. volatile关键字
        output.append("2. volatile关键字的作用是什么？\n");
        output.append("答：volatile有两个主要作用：\n");
        output.append("① 保证可见性：当一个线程修改被volatile修饰的变量时，其他线程能立即看到最新值\n");
        output.append("② 禁止指令重排序：通过内存屏障防止编译器和CPU的指令重排\n\n");
        
        output.append("volatile不能保证原子性，如count++这样的复合操作不是线程安全的。\n");
        output.append("适用场景：作为状态标志、双重检查锁定（DCL）、单例模式\n\n");
        
        // 3. 线程池参数选择
        output.append("3. 如何合理设置线程池参数？\n");
        output.append("答：需要考虑以下因素：\n");
        output.append("• 任务类型：CPU密集型、IO密集型、混合型\n");
        output.append("• CPU核心数：Runtime.getRuntime().availableProcessors()\n");
        output.append("• 内存资源：每个线程会占用一定栈空间\n");
        output.append("• 并发量：预估的并发任务量\n\n");
        
        output.append("常用估算公式：\n");
        output.append("• CPU密集型：线程数 = CPU核心数 + 1\n");
        output.append("• IO密集型：线程数 = CPU核心数 * (1 + IO耗时/CPU耗时)\n");
        output.append("            或 线程数 = CPU核心数 * 2\n\n");
        
        output.append("合理的队列选择：\n");
        output.append("• LinkedBlockingQueue：无界队列，适合请求量可控场景\n");
        output.append("• ArrayBlockingQueue：有界队列，适合内存敏感场景\n");
        output.append("• SynchronousQueue：无容量队列，适合要求快速响应的场景\n\n");
        
        // 4. AQS原理
        output.append("4. AQS的实现原理和应用？\n");
        output.append("答：AbstractQueuedSynchronizer(AQS)是Java并发包的基础，其原理：\n");
        output.append("• 使用volatile int state表示同步状态\n");
        output.append("• 使用FIFO队列管理等待的线程\n");
        output.append("• 使用CAS操作更新同步状态\n");
        output.append("• 提供独占模式和共享模式两种同步方式\n\n");
        
        output.append("AQS应用：\n");
        output.append("• 独占锁：ReentrantLock\n");
        output.append("• 读写锁：ReentrantReadWriteLock\n");
        output.append("• 信号量：Semaphore\n");
        output.append("• 倒计时器：CountDownLatch\n");
        output.append("• 循环栅栏：CyclicBarrier(内部使用ReentrantLock)\n\n");
        
        // 5. ThreadLocal原理及内存泄漏问题
        output.append("5. ThreadLocal的原理及内存泄漏问题？\n");
        output.append("答：ThreadLocal原理：\n");
        output.append("• 每个Thread维护一个ThreadLocalMap对象\n");
        output.append("• ThreadLocalMap的key是ThreadLocal对象的弱引用\n");
        output.append("• value是线程的变量副本\n\n");
        
        output.append("内存泄漏问题：\n");
        output.append("• 问题：ThreadLocalMap的Entry中key使用弱引用，但value是强引用\n");
        output.append("• 当ThreadLocal对象被回收后，key变为null，但value依然存在引用\n");
        output.append("• 如果线程长期存活（如线程池），则可能导致内存泄漏\n\n");
        
        output.append("解决方法：\n");
        output.append("• 使用完ThreadLocal后调用remove()\n");
        output.append("• 尽量将ThreadLocal声明为static final，避免频繁创建\n");
        output.append("• 使用try-finally确保及时清理\n\n");
        
        // 6. 死锁及解决方案
        output.append("6. 什么是死锁？如何避免和检测？\n");
        output.append("答：死锁是指两个或多个线程互相等待对方持有的锁，导致永久阻塞。\n\n");
        
        output.append("死锁产生的四个必要条件：\n");
        output.append("• 互斥：资源只能被一个线程占用\n");
        output.append("• 请求与保持：线程已获得资源，又提出新的资源请求\n");
        output.append("• 不剥夺：资源只能由持有者自愿释放\n");
        output.append("• 循环等待：存在环形的资源依赖关系\n\n");
        
        output.append("避免死锁的方法：\n");
        output.append("• 固定加锁顺序：对多个锁按照相同顺序获取\n");
        output.append("• 超时机制：使用tryLock(timeout)设置超时退出\n");
        output.append("• 避免嵌套锁：一个线程一次只获取一个锁\n");
        output.append("• 使用并发工具：优先使用并发容器和原子类\n\n");
        
        output.append("死锁检测方法：\n");
        output.append("• jstack命令：查看线程堆栈信息寻找死锁\n");
        output.append("• jconsole：可视化监控死锁\n");
        output.append("• VisualVM：图形化分析工具\n");
        
        updateOutput(output.toString());
    }
    
    /**
     * 更新输出文本
     */
    private void updateOutput(String text) {
        tvOutput.append(text);
    }
} 